પાંડાસ પર્ફોર્મન્સ ઓપ્ટિમાઇઝેશન: મેમરી વપરાશ ઘટાડવામાં માસ્ટરી મેળવવી

પાંડાસ એ ડેટા એનાલિસિસ માટેનું એક શક્તિશાળી પાયથોન લાઇબ્રેરી છે, જે લવચીક ડેટા સ્ટ્રક્ચર્સ અને ડેટા એનાલિસિસ ટૂલ્સ પ્રદાન કરે છે. જો કે, જ્યારે મોટા ડેટાસેટ્સ સાથે કામ કરવામાં આવે છે, ત્યારે મેમરીનો વપરાશ નોંધપાત્ર અવરોધ બની શકે છે, જે કામગીરીને અસર કરે છે અને તમારા પ્રોગ્રામને ક્રેશ પણ કરી શકે છે. આ વ્યાપક માર્ગદર્શિકા પાંડાસ મેમરી વપરાશને ઑપ્ટિમાઇઝ કરવા માટેની વિવિધ તકનીકોની શોધ કરે છે, જે તમને મોટા ડેટાસેટ્સને વધુ કાર્યક્ષમ અને અસરકારક રીતે હેન્ડલ કરવાની મંજૂરી આપે છે.

પાંડાસ મેમરી વપરાશને સમજવું

ઑપ્ટિમાઇઝેશન તકનીકોમાં ડૂબકી મારતા પહેલાં, પાંડાસ મેમરીમાં ડેટાને કેવી રીતે સ્ટોર કરે છે તે સમજવું મહત્વપૂર્ણ છે. પાંડાસ મુખ્યત્વે ડેટાફ્રેમ્સ અને સિરીઝમાં ડેટા સ્ટોર કરવા માટે NumPy એરેનો ઉપયોગ કરે છે. દરેક કૉલમનો ડેટા પ્રકાર મેમરી ફૂટપ્રિન્ટને નોંધપાત્ર રીતે અસર કરે છે. ઉદાહરણ તરીકે, `int64` કૉલમ `int32` કૉલમની સરખામણીમાં બમણી મેમરી વાપરે છે.

તમે .memory_usage() પદ્ધતિનો ઉપયોગ કરીને ડેટાફ્રેમની મેમરી વપરાશ ચકાસી શકો છો:

            import pandas as pd

data = {
    'col1': [1, 2, 3, 4, 5],
    'col2': ['A', 'B', 'C', 'D', 'E'],
    'col3': [1.1, 2.2, 3.3, 4.4, 5.5]
}

df = pd.DataFrame(data)

memory_usage = df.memory_usage(deep=True)
print(memory_usage)

            

              
                Copy
              
            
          

ઑબ્જેક્ટ (સ્ટ્રિંગ) કૉલમ્સના મેમરી વપરાશની ચોક્કસ ગણતરી કરવા માટે deep=True આર્ગ્યુમેન્ટ આવશ્યક છે.

મેમરી વપરાશ ઘટાડવાની તકનીકો

1. યોગ્ય ડેટા પ્રકારો પસંદ કરવા

મેમરી વપરાશ ઘટાડવામાં દરેક કૉલમ માટે યોગ્ય ડેટા પ્રકાર પસંદ કરવો એ સૌથી મૂળભૂત પગલું છે. પાંડાસ આપમેળે ડેટા પ્રકારોનો અંદાજ લગાવે છે, પરંતુ તે ઘણીવાર જરૂરી કરતાં વધુ મેમરી-સઘન પ્રકારો પર ડિફોલ્ટ થાય છે. ઉદાહરણ તરીકે, 0 થી 100 ની વચ્ચેની પૂર્ણાંકો ધરાવતા કૉલમને `int64` પ્રકાર સોંપવામાં આવી શકે છે, ભલે `int8` અથવા `uint8` પૂરતા હોય.

ઉદાહરણ: ન્યૂમેરિક પ્રકારોને ડાઉનકાસ્ટ કરવા

તમે pd.to_numeric() ફંક્શનનો ઉપયોગ કરીને ન્યૂમેરિક પ્રકારોને નાના રજૂઆતોમાં ડાઉનકાસ્ટ કરી શકો છો અને downcast પરિમાણનો ઉપયોગ કરી શકો છો:

            def reduce_mem_usage(df):
    """Iterate through all the columns of a dataframe and modify the data type
        to reduce memory usage.        
    """
    start_mem = df.memory_usage().sum() / 1024**2
    print('Memory usage of dataframe is {:.2f} MB'.format(start_mem))
    
    for col in df.columns:
        if df[col].dtype == 'object':
            continue # Skip strings, handle them separately

        col_type = df[col].dtype
        
        if col_type in ['int64','int32','int16']:
            c_min = df[col].min()
            c_max = df[col].max()
            if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:
                df[col] = df[col].astype(np.int8)
            elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:
                df[col] = df[col].astype(np.int16)
            elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:
                df[col] = df[col].astype(np.int32)
            else:
                df[col] = df[col].astype(np.int64)
        elif col_type in ['float64','float32']:
            c_min = df[col].min()
            c_max = df[col].max()
            if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:
                df[col] = df[col].astype(np.float16)
            elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:
                df[col] = df[col].astype(np.float32)
            else:
                df[col] = df[col].astype(np.float64)

    end_mem = df.memory_usage().sum() / 1024**2
    print('Memory usage after optimization is: {:.2f} MB'.format(end_mem))
    print('Decreased by {:.1f}%'.format(100 * (start_mem - end_mem) / start_mem))
    
    return df

            

              
                Copy
              
            
          

ઉદાહરણ: સ્ટ્રિંગ્સને વર્ગીકૃત પ્રકારોમાં રૂપાંતરિત કરવું

જો કોઈ કૉલમમાં અનન્ય સ્ટ્રિંગ મૂલ્યોની મર્યાદિત સંખ્યા હોય, તો તેને વર્ગીકૃત પ્રકારમાં રૂપાંતરિત કરવાથી મેમરી વપરાશમાં નોંધપાત્ર ઘટાડો થઈ શકે છે. વર્ગીકૃત પ્રકારો ફક્ત એક જ વાર અનન્ય મૂલ્યો સ્ટોર કરે છે અને કૉલમમાં દરેક તત્વને અનન્ય મૂલ્યોનો સંદર્ભ આપતા પૂર્ણાંક કોડ તરીકે રજૂ કરે છે.

            df['col2'] = df['col2'].astype('category')

            

              
                Copy
              
            
          

વૈશ્વિક ઇ-કોમર્સ પ્લેટફોર્મ માટેના ગ્રાહક વ્યવહારોના ડેટાસેટનો વિચાર કરો. 'દેશ' કૉલમમાં માત્ર થોડાક સો અનન્ય દેશના નામ હોઈ શકે છે, જ્યારે ડેટાસેટમાં લાખો વ્યવહારો હોય છે. 'દેશ' કૉલમને વર્ગીકૃત પ્રકારમાં રૂપાંતરિત કરવાથી મેમરી વપરાશમાં નાટ્યાત્મક ઘટાડો થશે.

2. ચંકીંગ અને ઇટરેશન

જ્યારે અત્યંત મોટા ડેટાસેટ્સ સાથે કામ કરવું કે જે મેમરીમાં ફિટ થઈ શકતા નથી, ત્યારે તમે pd.read_csv() અથવા pd.read_excel() માં chunksize પરિમાણનો ઉપયોગ કરીને ડેટાને ચંક્સમાં પ્રોસેસ કરી શકો છો. આ તમને નાના, વ્યવસ્થાપિત ટુકડાઓમાં ડેટા લોડ અને પ્રોસેસ કરવાની મંજૂરી આપે છે.

            for chunk in pd.read_csv('large_dataset.csv', chunksize=100000):
    # Process the chunk (e.g., perform calculations, filtering, aggregation)
    print(f"Processing chunk with {len(chunk)} rows")
    # Optionally, append results to a file or database.

            

              
                Copy
              
            
          

ઉદાહરણ: મોટી લોગ ફાઇલોની પ્રક્રિયા કરવી

વૈશ્વિક નેટવર્ક ઇન્ફ્રાસ્ટ્રક્ચરથી વિશાળ લોગ ફાઇલની પ્રક્રિયા કરવાની કલ્પના કરો. લોગ ફાઇલ મેમરીમાં ફિટ થવા માટે ખૂબ મોટી છે. ચંકીંગનો ઉપયોગ કરીને, તમે લોગ ફાઇલ દ્વારા પુનરાવર્તન કરી શકો છો, ચોક્કસ ઇવેન્ટ્સ અથવા પેટર્ન માટે દરેક ચંકનું વિશ્લેષણ કરી શકો છો અને મેમરી મર્યાદાને ઓળંગ્યા વિના પરિણામો એકત્રિત કરી શકો છો.

3. ફક્ત જરૂરી કૉલમ્સ પસંદ કરવા

ઘણીવાર, ડેટાસેટ્સમાં એવી કૉલમ્સ હોય છે જે તમારા વિશ્લેષણ માટે સુસંગત નથી. ફક્ત જરૂરી કૉલમ્સ લોડ કરવાથી મેમરી વપરાશમાં નોંધપાત્ર ઘટાડો થઈ શકે છે. તમે pd.read_csv() માં usecols પરિમાણનો ઉપયોગ કરીને ઇચ્છિત કૉલમ્સનો ઉલ્લેખ કરી શકો છો.

            df = pd.read_csv('large_dataset.csv', usecols=['col1', 'col2', 'col3'])

            

              
                Copy
              
            
          

ઉદાહરણ: વેચાણ ડેટાનું વિશ્લેષણ કરવું

જો તમે ટોચના પ્રદર્શન કરતા ઉત્પાદનોને ઓળખવા માટે વેચાણ ડેટાનું વિશ્લેષણ કરી રહ્યા છો, તો તમારે કદાચ ફક્ત 'ઉત્પાદન ID', 'વેચાણ જથ્થો' અને 'વેચાણ આવક' કૉલમ્સની જરૂર પડશે. ફક્ત આ કૉલમ્સ લોડ કરવાથી સમગ્ર ડેટાસેટ લોડ કરવાની તુલનામાં મેમરી વપરાશમાં ઘટાડો થશે, જેમાં ગ્રાહકની વસ્તી વિષયક માહિતી, શિપિંગ સરનામાં અને અન્ય અપ્રસ્તુત માહિતી શામેલ હોઈ શકે છે.

4. સ્પાર્સ ડેટા સ્ટ્રક્ચર્સનો ઉપયોગ કરવો

જો તમારા ડેટાફ્રેમમાં ઘણા ગુમ થયેલા મૂલ્યો (NaNs) અથવા શૂન્ય હોય, તો તમે ડેટાને વધુ કાર્યક્ષમ રીતે રજૂ કરવા માટે સ્પાર્સ ડેટા સ્ટ્રક્ચર્સનો ઉપયોગ કરી શકો છો. સ્પાર્સ ડેટાફ્રેમ્સ ફક્ત ગુમ થયેલ અથવા શૂન્ય સિવાયના મૂલ્યો સ્ટોર કરે છે, જ્યારે સ્પાર્સ ડેટા સાથે કામ કરતી વખતે મેમરી વપરાશમાં નોંધપાત્ર ઘટાડો કરે છે.

            sparse_series = df['col1'].astype('Sparse[float]')
sparse_df = sparse_series.to_frame()

            

              
                Copy
              
            
          

ઉદાહરણ: ગ્રાહક રેટિંગ્સનું વિશ્લેષણ કરવું

મોટી સંખ્યામાં ઉત્પાદનો માટે ગ્રાહક રેટિંગ્સના ડેટાસેટનો વિચાર કરો. મોટાભાગના ગ્રાહકો ફક્ત ઉત્પાદનોના નાના સબસેટને રેટ કરશે, જેના પરિણામે રેટિંગ્સનું સ્પાર્સ મેટ્રિક્સ થશે. આ ડેટા સ્ટોર કરવા માટે સ્પાર્સ ડેટાફ્રેમનો ઉપયોગ કરવાથી ગાઢ ડેટાફ્રેમની સરખામણીમાં મેમરી વપરાશમાં નોંધપાત્ર ઘટાડો થશે.

5. ડેટાની કૉપિ કરવાનું ટાળવું

પાંડાસ કામગીરી કેટલીકવાર ડેટાફ્રેમ્સની કૉપિ બનાવી શકે છે, જેનાથી મેમરી વપરાશમાં વધારો થાય છે. કોઈ ડેટાફ્રેમને સ્થળ પર સંશોધિત કરવાથી (જ્યારે શક્ય હોય ત્યારે) બિનજરૂરી કૉપિ કરવાનું ટાળવામાં મદદ મળી શકે છે.

ઉદાહરણ તરીકે, આના બદલે:

            df = df[df['col1'] > 10]

            

              
                Copy
              
            
          

આનો ઉપયોગ કરવાનું વિચારો:

            df.drop(df[df['col1'] <= 10].index, inplace=True)

            

              
                Copy
              
            
          

`inplace=True` આર્ગ્યુમેન્ટ કૉપિ બનાવ્યા વિના ડેટાફ્રેમને સીધી સંશોધિત કરે છે.

6. સ્ટ્રિંગ સ્ટોરેજને ઑપ્ટિમાઇઝ કરવું

સ્ટ્રિંગ કૉલમ્સ નોંધપાત્ર મેમરી વાપરી શકે છે, ખાસ કરીને જો તેમાં લાંબી સ્ટ્રિંગ્સ અથવા ઘણા અનન્ય મૂલ્યો હોય. સ્ટ્રિંગ્સને વર્ગીકૃત પ્રકારોમાં રૂપાંતરિત કરવું, જેમ કે અગાઉ ઉલ્લેખ કર્યો છે, તે એક અસરકારક તકનીક છે. બીજો અભિગમ એ છે કે જો શક્ય હોય તો નાના સ્ટ્રિંગ રજૂઆતોનો ઉપયોગ કરવો.

ઉદાહરણ: સ્ટ્રિંગ લંબાઈ ઘટાડવી

જો કોઈ કૉલમમાં આઇડેન્ટિફાયર્સ હોય જે સ્ટ્રિંગ તરીકે સ્ટોર કરવામાં આવે છે પરંતુ તેને પૂર્ણાંકો તરીકે રજૂ કરી શકાય છે, તો તેમને પૂર્ણાંકોમાં રૂપાંતરિત કરવાથી મેમરી બચાવી શકાય છે. ઉદાહરણ તરીકે, ઉત્પાદન ID કે જે હાલમાં "PROD-1234" જેવા સ્ટ્રિંગ્સ તરીકે સંગ્રહિત છે તેને પૂર્ણાંક ID માં મેપ કરી શકાય છે.

7. મોટા-કરતાં-મેમરી ડેટાસેટ્સ માટે Dask નો ઉપયોગ કરવો

ડેટાસેટ્સ માટે કે જે ચંકીંગ સાથે પણ, મેમરીમાં ફિટ થવા માટે ખરેખર ખૂબ મોટા છે, Dask નો ઉપયોગ કરવાનું વિચારો. Dask એ એક સમાંતર કમ્પ્યુટિંગ લાઇબ્રેરી છે જે પાંડાસ અને NumPy સાથે સારી રીતે સંકલિત થાય છે. તે તમને મોટા-કરતાં-મેમરી ડેટાસેટ્સ સાથે કામ કરવાની મંજૂરી આપે છે તેમને નાના ટુકડાઓમાં તોડીને અને બહુવિધ કોરો અથવા બહુવિધ મશીનો પર સમાંતરમાં પ્રક્રિયા કરીને.

            import dask.dataframe as dd

ddf = dd.read_csv('large_dataset.csv')

# Perform operations on the Dask DataFrame (e.g., filtering, aggregation)
result = ddf[ddf['col1'] > 10].groupby('col2').mean().compute()

            

              
                Copy
              
            
          

compute() પદ્ધતિ વાસ્તવિક ગણતરીને ટ્રિગર કરે છે અને પરિણામો ધરાવતું પાંડાસ ડેટાફ્રેમ પરત કરે છે.

શ્રેષ્ઠ પ્રથાઓ અને વિચારણાઓ

• તમારા કોડને પ્રોફાઇલ કરો: મેમરી અવરોધોને ઓળખવા માટે પ્રોફાઇલિંગ ટૂલ્સનો ઉપયોગ કરો અને તમારા ઑપ્ટિમાઇઝેશન પ્રયત્નોને સૌથી પ્રભાવશાળી ક્ષેત્રો પર કેન્દ્રિત કરો.
• વિવિધ તકનીકોનું પરીક્ષણ કરો: શ્રેષ્ઠ મેમરી ઘટાડવાની તકનીક તમારા ડેટાસેટની વિશિષ્ટ લાક્ષણિકતાઓ પર આધારિત છે. તમારા ઉપયોગના કેસ માટે શ્રેષ્ઠ ઉકેલ શોધવા માટે વિવિધ અભિગમો સાથે પ્રયોગ કરો.
• મેમરી વપરાશનું નિરીક્ષણ કરો: ડેટા પ્રોસેસિંગ દરમિયાન મેમરી વપરાશનો ટ્રૅક રાખો જેથી ખાતરી થાય કે તમારા ઑપ્ટિમાઇઝેશન અસરકારક છે અને આઉટ-ઓફ-મેમરી ભૂલોને અટકાવે છે.
• તમારા ડેટાને સમજો: સૌથી યોગ્ય ડેટા પ્રકારો અને ઑપ્ટિમાઇઝેશન તકનીકો પસંદ કરવા માટે તમારા ડેટાની ઊંડી સમજણ નિર્ણાયક છે.
• ટ્રેડ-ઑફ્સને ધ્યાનમાં લો: કેટલીક મેમરી ઑપ્ટિમાઇઝેશન તકનીકો થોડો કામગીરી ઓવરહેડ લાવી શકે છે. ઘટાડેલા મેમરી વપરાશના ફાયદાઓને કોઈપણ સંભવિત કામગીરીની અસર સામે તોલો.
• તમારા ઑપ્ટિમાઇઝેશનનું દસ્તાવેજીકરણ કરો: તમે અમલમાં મૂકેલી મેમરી ઑપ્ટિમાઇઝેશન તકનીકોને સ્પષ્ટપણે દસ્તાવેજ કરો જેથી ખાતરી થાય કે તમારો કોડ જાળવણી કરી શકાય તેવો છે અને અન્ય લોકો દ્વારા સમજી શકાય તેવો છે.

નિષ્કર્ષ

મોટા ડેટાસેટ્સ સાથે કાર્યક્ષમ અને અસરકારક રીતે કામ કરવા માટે પાંડાસ મેમરી વપરાશને ઑપ્ટિમાઇઝ કરવું આવશ્યક છે. પાંડાસ ડેટાને કેવી રીતે સ્ટોર કરે છે તે સમજીને, યોગ્ય ડેટા પ્રકારો પસંદ કરીને, ચંકીંગનો ઉપયોગ કરીને અને અન્ય ઑપ્ટિમાઇઝેશન તકનીકોનો ઉપયોગ કરીને, તમે મેમરી વપરાશમાં નોંધપાત્ર ઘટાડો કરી શકો છો અને તમારા ડેટા વિશ્લેષણ વર્કફ્લોની કામગીરીને સુધારી શકો છો. આ માર્ગદર્શિકાએ પાંડાસમાં મેમરી વપરાશ ઘટાડવામાં માસ્ટરી મેળવવા માટેની મુખ્ય તકનીકો અને શ્રેષ્ઠ પ્રથાઓની વ્યાપક ઝાંખી પ્રદાન કરી છે. તમારા કોડને પ્રોફાઇલ કરવાનું, વિવિધ તકનીકોનું પરીક્ષણ કરવાનું અને તમારા વિશિષ્ટ ઉપયોગના કેસ માટે શ્રેષ્ઠ પરિણામો પ્રાપ્ત કરવા માટે મેમરી વપરાશનું નિરીક્ષણ કરવાનું યાદ રાખો. આ સિદ્ધાંતો લાગુ કરીને, તમે પાંડાસની સંપૂર્ણ સંભાવનાને અનલૉક કરી શકો છો અને સૌથી વધુ માગણી કરતા ડેટા વિશ્લેષણ પડકારોનો પણ સામનો કરી શકો છો.

આ તકનીકોમાં નિપુણતા મેળવીને, વિશ્વભરના ડેટા વૈજ્ઞાનિકો અને વિશ્લેષકો મોટા ડેટાસેટ્સને હેન્ડલ કરી શકે છે, પ્રક્રિયા ઝડપમાં સુધારો કરી શકે છે અને તેમના ડેટામાંથી વધુ ઊંડી સમજ મેળવી શકે છે. આ વધુ કાર્યક્ષમ સંશોધન, વધુ સારી જાણકાર વ્યવસાયિક નિર્ણયો અને આખરે, વધુ ડેટા-સંચાલિત વિશ્વમાં ફાળો આપે છે.